package main

import (
	"encoding/json"
	"fmt"
	"math"
	"net/http"
)

// 定义接收数据的结构体
type SensorData struct {
	DeviceID  string              `json:"device_id"`
	Timestamp int64               `json:"timestamp"`
	Data      map[string]float64  `json:"data"` // 传感器数据
	Meta      map[string]MetaInfo `json:"meta"` // μ和σ元数据
	Signature string              `json:"signature"`
}

// μ和σ信息结构体
type MetaInfo struct {
	Mu    float64 `json:"mu"`    // 均值
	Sigma float64 `json:"sigma"` // 标准差
}

// 数据状态枚举
type DataStatus string

const (
	StatusNormal   DataStatus = "normal"   // 正常 (1.5σ内)
	StatusAbnormal DataStatus = "abnormal" // 异常 (1.5σ--3σ)
	StatusError    DataStatus = "error"    // 错误 (超出3σ)
)

// 数据分析结果
type AnalysisResult struct {
	Value     float64    `json:"value"`     // 原始数据值
	Status    DataStatus `json:"status"`    // 数据状态
	Deviation float64    `json:"deviation"` // 偏差倍数
	Mu        float64    `json:"mu"`        // 均值
	Sigma     float64    `json:"sigma"`     // 标准差
}

// 判断数据状态的核心函数
func JudgeDataStatus(value, mu, sigma float64) DataStatus {
	if sigma == 0 {
		return StatusNormal // 避免除零错误
	}

	deviation := math.Abs(value-mu) / sigma

	if deviation <= 1.5 {
		return StatusNormal
	} else if deviation <= 3.0 {
		return StatusAbnormal
	} else {
		return StatusError
	}
}

// 分析所有传感器数据
func AnalyzeSensorData(sensorData SensorData) map[string]AnalysisResult {
	results := make(map[string]AnalysisResult)

	for param, value := range sensorData.Data {
		// 获取对应参数的μ和σ
		if metaInfo, exists := sensorData.Meta[param]; exists {
			mu := metaInfo.Mu
			sigma := metaInfo.Sigma
			status := JudgeDataStatus(value, mu, sigma)

			var deviation float64
			if sigma != 0 {
				deviation = math.Abs(value-mu) / sigma
			}

			results[param] = AnalysisResult{
				Value:     value,
				Status:    status,
				Deviation: deviation,
				Mu:        mu,
				Sigma:     sigma,
			}
		}
	}

	return results
}

// HTTP处理函数示例
func HandleDataUpload(w http.ResponseWriter, r *http.Request) {
	var sensorData SensorData

	// 解析JSON数据
	if err := json.NewDecoder(r.Body).Decode(&sensorData); err != nil {
		http.Error(w, "Invalid JSON", http.StatusBadRequest)
		return
	}

	// 分析数据状态
	analysisResults := AnalyzeSensorData(sensorData)

	// 打印分析结果（实际应用中可能是存储到数据库或其他处理）
	fmt.Printf("设备 %s 的数据分析结果:\n", sensorData.DeviceID)
	for param, result := range analysisResults {
		fmt.Printf("  %s: %.4f (μ=%.4f, σ=%.4f) -> 状态: %s (偏差: %.2fσ)\n",
			param, result.Value, result.Mu, result.Sigma, result.Status, result.Deviation)
	}

	// 检查是否有异常或错误数据
	hasAbnormal := false
	hasError := false
	for _, result := range analysisResults {
		switch result.Status {
		case StatusAbnormal:
			hasAbnormal = true
		case StatusError:
			hasError = true
		}
	}

	// 构造响应
	response := map[string]interface{}{
		"status":       "success",
		"device_id":    sensorData.DeviceID,
		"timestamp":    sensorData.Timestamp,
		"analysis":     analysisResults,
		"has_abnormal": hasAbnormal,
		"has_error":    hasError,
	}

	// 根据数据状态设置不同的HTTP状态码
	statusCode := http.StatusOK
	if hasError {
		statusCode = http.StatusUnprocessableEntity // 422 数据错误
		response["message"] = "检测到错误数据"
	} else if hasAbnormal {
		statusCode = http.StatusAccepted // 202 有异常数据但可接受
		response["message"] = "检测到异常数据"
	} else {
		response["message"] = "所有数据正常"
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(statusCode)
	json.NewEncoder(w).Encode(response)
}

// 主函数示例
func main() {
	// 设置路由
	http.HandleFunc("/data/upload", HandleDataUpload)

	fmt.Println("服务器启动在 :5000")
	fmt.Println("数据状态判断功能已就绪")

	// 启动服务器
	if err := http.ListenAndServe(":5000", nil); err != nil {
		fmt.Printf("服务器启动失败: %v\n", err)
	}
}
